(function () {
    "use strict";

    angular.module('core').controller('reportFinanceiroPL000001Controller', controller);
    controller.$inject = ['$scope', '$filter', '$timeout', 'toolsService', 'lookupService', 'fluxoCaixaService'];

    function controller($scope, $filter, $timeout, toolsService, lookupService, fluxoCaixaService) {
        $scope.initializeLayout('Fluxo de Caixa');


        $scope.ObjReceber = [];
        $scope.ObjPagar = [];
        $scope.state = {
            filtro: {
                ativo: false,
                base: { ano: "2018" }
            },
        };
        $scope.tabs = {
            enum: {
                vendas: 0,
                vendedores: 1,
                produtos: 2,
                fidelidade: 3,
                crm: 4,
            },
            corrente: 0,
            select: function (index) {
                $scope.tabs.corrente = index;
                $scope.refresh();
            },
        };
        $scope.charts = {
            totais: {
                ValorPago: null,
                ValorMeta: null,
                NumeroVendas: null,
                ValorPorAtendimento: null,
                PecasPorAtendimento: null,
                PercentualTroca: null,
                PrecoMedio: null,
                QuantidadeVenda: null,
                getAll: function () {
                    fluxoCaixaService
                        .getSumario($scope.state.filtro.args)
                        .then(
                        function (response) {
                            if (response.Status < 0) {
                                $scope.tools.toastr.error(response.Message, 'Serviço');
                            } else {
                                $scope.charts.totais.ValorPago = response.Data.ValorPago;
                                $scope.charts.totais.ValorMeta = response.Data.ValorMeta;
                                $scope.charts.totais.NumeroVendas = response.Data.NumeroVendas;
                                $scope.charts.totais.ValorPorAtendimento = response.Data.ValorPorAtendimento;
                                $scope.charts.totais.PecasPorAtendimento = response.Data.PecasPorAtendimento;
                                $scope.charts.totais.PercentualTroca = response.Data.PercentualTroca;
                                $scope.charts.totais.PrecoMedio = response.Data.PrecoMedio;
                                $scope.charts.totais.QuantidadeVenda = response.Data.QuantidadeVenda;
                            }
                        },
                        function (_error) {
                            $scope.tools.toastr.error('Não foi possível conectar com o(s) servidor(es)');
                        });
                },
            },
            evolucaoVenda: {
                carregando: false,
                vazio: false,
                fillChart: function () {
                    $scope.charts.evolucaoVenda.carregando = true;
                    $scope.charts.evolucaoVenda.vazio = false;
                    fluxoCaixaService
                        .chartEvolucaoVenda($scope.state.filtro.args)
                        .then(
                        function (response) {
                            if (response.Status < 0) {
                                $scope.tools.toastr.error(response.Message, 'Serviço');
                                console.error(response.Exception);
                            } else {
                                $timeout(function () {
                                    $scope.charts.evolucaoVenda.vazio =
                                        toolsService.buildChart("#chart-evolucao-venda", "R$", response.Data);
                                });
                            }
                            $scope.charts.evolucaoVenda.carregando = false;
                        },
                        function (_error) {
                            $scope.charts.evolucaoVenda.carregando = false;
                            $scope.tools.toastr.error('Não foi possível conectar com o(s) servidor(es)');
                            console.error(_error);
                        }
                        );
                },
            },
            evolucaoVendaAcumulada: {
                carregando: false,
                vazio: false,
                fillChart: function () {
                    $scope.charts.evolucaoVendaAcumulada.carregando = true;
                    $scope.charts.evolucaoVendaAcumulada.vazio = false;
                    fluxoCaixaService
                        .chartEvolucaoVendaAcumulada($scope.state.filtro.args)
                        .then(
                        function (response) {
                            if (response.Status < 0) {
                                $scope.tools.toastr.error(response.Message, 'Serviço');
                                console.error(response.Exception);
                            } else {
                                $timeout(function () {
                                    $scope.charts.evolucaoVendaAcumulada.vazio =
                                        toolsService.buildChart("#chart-evolucao-venda-acumulada", "R$", response.Data);
                                });
                            }
                            $scope.charts.evolucaoVendaAcumulada.carregando = false;
                        },
                        function (_error) {
                            $scope.charts.evolucaoVendaAcumulada.carregando = false;
                            $scope.tools.toastr.error('Não foi possível conectar com o(s) servidor(es)');
                            console.error(_error);
                        }
                        );
                },
            },
            grupo: {
                carregando: false,
                vazio: false,
                fillChart: function () {
                    $scope.charts.grupo.carregando = true;
                    $scope.charts.grupo.vazio = false;
                    /* comproe o filtro do desempenho de vendedor que é baseado em ItemVendaVarejo */
                    var args = {
                        filtro: {
                            VendaVarejo: $scope.state.filtro.args.filtro,
                        },
                        tipoPeriodo: $scope.state.filtro.args.tipoPeriodo,
                        periodo: $scope.state.filtro.args.periodo,
                    };

                    fluxoCaixaService
                        .chartGrupo(args)
                        .then(
                        function (response) {
                            if (response.Status < 0) {
                                $scope.tools.toastr.error(response.Message, 'Serviço');
                                console.error(response.Exception);
                            } else {
                                $timeout(function () {
                                    $scope.charts.grupo.vazio =
                                        toolsService.buildChart("#chart-grupo", "R$", response.Data);
                                });
                            }
                            $scope.charts.grupo.carregando = false;
                        },
                        function (_error) {
                            $scope.charts.grupo.carregando = false;
                            $scope.tools.toastr.error('Não foi possível conectar com o(s) servidor(es)');
                            console.error(_error);
                        }
                        );
                },
            },
            subgrupo: {
                carregando: false,
                vazio: false,
                fillChart: function () {
                    $scope.charts.subgrupo.carregando = true;
                    $scope.charts.subgrupo.vazio = false;
                    /* comproe o filtro do desempenho de vendedor que é baseado em ItemVendaVarejo */
                    var args = {
                        filtro: {
                            VendaVarejo: $scope.state.filtro.args.filtro,
                        },
                        tipoPeriodo: $scope.state.filtro.args.tipoPeriodo,
                        periodo: $scope.state.filtro.args.periodo,
                    };

                    fluxoCaixaService
                        .chartSubgrupo(args)
                        .then(
                        function (response) {
                            if (response.Status < 0) {
                                $scope.tools.toastr.error(response.Message, 'Serviço');
                                console.error(response.Exception);
                            } else {
                                $timeout(function () {
                                    $scope.charts.subgrupo.vazio =
                                        toolsService.buildChart("#chart-subgrupo", "R$", response.Data);
                                });
                            }
                            $scope.charts.subgrupo.carregando = false;
                        },
                        function (_error) {
                            $scope.charts.subgrupo.carregando = false;
                            $scope.tools.toastr.error('Não foi possível conectar com o(s) servidor(es)');
                            console.error(_error);
                        }
                        );
                },
            },
            tipo: {
                carregando: false,
                vazio: false,
                fillChart: function () {
                    $scope.charts.tipo.carregando = true;
                    $scope.charts.tipo.vazio = false;
                    /* comproe o filtro do desempenho de vendedor que é baseado em ItemVendaVarejo */
                    var args = {
                        filtro: {
                            VendaVarejo: $scope.state.filtro.args.filtro,
                        },
                        tipoPeriodo: $scope.state.filtro.args.tipoPeriodo,
                        periodo: $scope.state.filtro.args.periodo,
                    };

                    fluxoCaixaService
                        .chartTipo(args)
                        .then(
                        function (response) {
                            if (response.Status < 0) {
                                $scope.tools.toastr.error(response.Message, 'Serviço');
                                console.error(response.Exception);
                            } else {
                                $timeout(function () {
                                    $scope.charts.tipo.vazio =
                                        toolsService.buildChart("#chart-tipo", "R$", response.Data);
                                });
                            }
                            $scope.charts.tipo.carregando = false;
                        },
                        function (_error) {
                            $scope.charts.tipo.carregando = false;
                            $scope.tools.toastr.error('Não foi possível conectar com o(s) servidor(es)');
                            console.error(_error);
                        }
                        );
                },
            },
            colecao: {
                carregando: false,
                vazio: false,
                fillChart: function () {
                    $scope.charts.colecao.carregando = true;
                    $scope.charts.colecao.vazio = false;
                    /* comproe o filtro do desempenho de vendedor que é baseado em ItemVendaVarejo */
                    var args = {
                        filtro: {
                            VendaVarejo: $scope.state.filtro.args.filtro,
                        },
                        tipoPeriodo: $scope.state.filtro.args.tipoPeriodo,
                        periodo: $scope.state.filtro.args.periodo,
                    };

                    fluxoCaixaService
                        .chartColecao(args)
                        .then(
                        function (response) {
                            if (response.Status < 0) {
                                $scope.tools.toastr.error(response.Message, 'Serviço');
                                console.error(response.Exception);
                            } else {
                                $timeout(function () {
                                    $scope.charts.colecao.vazio =
                                        toolsService.buildChart("#chart-colecao", "R$", response.Data);
                                });
                            }
                            $scope.charts.colecao.carregando = false;
                        },
                        function (_error) {
                            $scope.charts.colecao.carregando = false;
                            $scope.tools.toastr.error('Não foi possível conectar com o(s) servidor(es)');
                            console.error(_error);
                        }
                        );
                },
            },
            linha: {
                carregando: false,
                vazio: false,
                fillChart: function () {
                    $scope.charts.linha.carregando = true;
                    $scope.charts.linha.vazio = false;
                    /* comproe o filtro do desempenho de vendedor que é baseado em ItemVendaVarejo */
                    var args = {
                        filtro: {
                            VendaVarejo: $scope.state.filtro.args.filtro,
                        },
                        tipoPeriodo: $scope.state.filtro.args.tipoPeriodo,
                        periodo: $scope.state.filtro.args.periodo,
                    };

                    fluxoCaixaService
                        .chartLinha(args)
                        .then(
                        function (response) {
                            if (response.Status < 0) {
                                $scope.tools.toastr.error(response.Message, 'Serviço');
                                console.error(response.Exception);
                            } else {
                                $timeout(function () {
                                    $scope.charts.linha.vazio =
                                        toolsService.buildChart("#chart-linha", "R$", response.Data);
                                });
                            }
                            $scope.charts.linha.carregando = false;
                        },
                        function (_error) {
                            $scope.charts.linha.carregando = false;
                            $scope.tools.toastr.error('Não foi possível conectar com o(s) servidor(es)');
                            console.error(_error);
                        }
                        );
                },
            },
            marca: {
                carregando: false,
                vazio: false,
                fillChart: function () {
                    $scope.charts.marca.carregando = true;
                    $scope.charts.marca.vazio = false;
                    /* comproe o filtro do desempenho de vendedor que é baseado em ItemVendaVarejo */
                    var args = {
                        filtro: {
                            VendaVarejo: $scope.state.filtro.args.filtro,
                        },
                        tipoPeriodo: $scope.state.filtro.args.tipoPeriodo,
                        periodo: $scope.state.filtro.args.periodo,
                    };

                    fluxoCaixaService
                        .chartMarca(args)
                        .then(
                        function (response) {
                            if (response.Status < 0) {
                                $scope.tools.toastr.error(response.Message, 'Serviço');
                                console.error(response.Exception);
                            } else {
                                $timeout(function () {
                                    $scope.charts.marca.vazio =
                                        toolsService.buildChart("#chart-marca", "R$", response.Data);
                                });
                            }
                            $scope.charts.marca.carregando = false;
                        },
                        function (_error) {
                            $scope.charts.marca.carregando = false;
                            $scope.tools.toastr.error('Não foi possível conectar com o(s) servidor(es)');
                            console.error(_error);
                        }
                        );
                },
            },
            desempenhoLoja: {
                carregando: false,
                vazio: false,
                data: [],
                getAll: function () {
                    $scope.charts.desempenhoLoja.carregando = true;
                    $scope.charts.desempenhoLoja.vazio = false;
                    fluxoCaixaService
                        .getDesempenhoLoja($scope.state.filtro.args)
                        .then(
                        function (response) {
                            if (response.Status < 0) {
                                $scope.tools.toastr.error(response.Message, 'Serviço');
                                console.error(response.Exception);
                            } else {
                                angular.copy(angular.fromJson(response.Data), $scope.charts.desempenhoLoja.data);
                                $scope.charts.desempenhoLoja.vazio = (!response.Data || !response.Data.length);
                            }
                            $scope.charts.desempenhoLoja.carregando = false;
                        },
                        function (_error) {
                            $scope.charts.desempenhoLoja.carregando = false;
                            $scope.tools.toastr.error('Não foi possível conectar com o(s) servidor(es)');
                            console.error(_error);
                        }
                        );
                },
            },
            desempenhoVendedor: {
                carregando: false,
                vazio: false,
                data: [],
                getAll: function () {
                    $scope.charts.desempenhoVendedor.carregando = true;
                    $scope.charts.desempenhoVendedor.vazio = false;

                    /* comproe o filtro do desempenho de vendedor que é baseado em ItemVendaVarejo */
                    var args = {
                        filtro: {
                            VendaVarejo: $scope.state.filtro.args.filtro,
                        },
                        tipoPeriodo: $scope.state.filtro.args.tipoPeriodo,
                        periodo: $scope.state.filtro.args.periodo,
                    };

                    fluxoCaixaService
                        .getDesempenhoVendedor(args)
                        .then(
                        function (response) {
                            if (response.Status < 0) {
                                $scope.tools.toastr.error(response.Message, 'Serviço');
                                console.error(response.Exception);
                            } else {
                                angular.copy(angular.fromJson(response.Data), $scope.charts.desempenhoVendedor.data);
                                $scope.charts.desempenhoVendedor.vazio = (!response.Data || !response.Data.length);
                            }
                            $scope.charts.desempenhoVendedor.carregando = false;
                        },
                        function (_error) {
                            $scope.charts.desempenhoVendedor.carregando = false;
                            $scope.tools.toastr.error('Não foi possível conectar com o(s) servidor(es)');
                            console.error(_error);
                        }
                        );
                },
            },
            desempenhoProduto: {
                carregando: false,
                vazio: false,
                data: [],
                getAll: function () {
                    $scope.charts.desempenhoProduto.carregando = true;
                    $scope.charts.desempenhoProduto.vazio = false;

                    /* comproe o filtro do desempenho de vendedor que é baseado em ItemVendaVarejo */
                    var args = {
                        filtro: {
                            VendaVarejo: $scope.state.filtro.args.filtro,
                        },
                        tipoPeriodo: $scope.state.filtro.args.tipoPeriodo,
                        periodo: $scope.state.filtro.args.periodo,
                    };

                    fluxoCaixaService
                        .getDesempenhoProduto(args)
                        .then(
                        function (response) {
                            if (response.Status < 0) {
                                $scope.tools.toastr.error(response.Message, 'Serviço');
                                console.error(response.Exception);
                            } else {
                                angular.copy(angular.fromJson(response.Data), $scope.charts.desempenhoProduto.data);
                                $scope.charts.desempenhoProduto.vazio = (!response.Data || !response.Data.length);
                            }
                            $scope.charts.desempenhoProduto.carregando = false;
                        },
                        function (_error) {
                            $scope.charts.desempenhoProduto.carregando = false;
                            $scope.tools.toastr.error('Não foi possível conectar com o(s) servidor(es)');
                            console.error(_error);
                        }
                        );
                },
            },
        };
        $scope.auxiliar = {
            status: {
                data: [
                    { Codigo: 1, Nome: "Concluído" },
                    { Codigo: 2, Nome: "Cancelado" },
                ],
            },
            anosBase: []
        };

        /* funções */
        $scope.initialize = function () {
            $scope.clearFilter();
        };

        $scope.refresh = function () {
            $scope.GetReportReceber();
            $scope.GetReportPagar();
            $scope.GetAnoBase();

        };
        $scope.GetAnoBase = function () {
            fluxoCaixaService.GetAnoBase().then(function (response) {
                $scope.auxiliar.anosBase = response.Data;

            },
            function (_error)
            { }
            );
        }
        $scope.clearFilter = function () {
            $scope.state.filtro.args = {
                filtro: {
                    Status: 1, //concluido: 1, cancelado: 2
                },
                tipoPeriodo: 0, //hoje, ontem, 7-dias, no-mes, no-ano, personalizado
                periodo: { De: null, Ate: null },
            };
            $scope.refresh();
        };
        $scope.toggleFilter = function () {
            $scope.state.filtro.ativo = !$scope.state.filtro.ativo;
        };

        $scope.GetReportReceber = function () {
            fluxoCaixaService.GetReport($scope.state.filtro.base.ano, true).then(function (response) {

                $scope.ObjReceber = response.Data;

            },
            function (_error)
            { }
            );
        }

        $scope.GetReportPagar = function () {
            fluxoCaixaService.GetReport($scope.state.filtro.base.ano, false).then(function (response) {

                $scope.ObjPagar = response.Data;

            },
            function (_error)
            { }
            );
        }
        $scope.GetSubTotal = function (itens, mes) {
            //Calcula SubTotal
            var valor = 0;
            if (mes == 0) {
                angular.forEach(itens, function (value, key) {
                    valor += value.valororiginal;
                });
            }
            else {

                angular.forEach(itens, function (value, key) {
                    if (mes == 1)
                        valor += value.mes1;
                    if (mes == 2)
                        valor += value.mes2;
                    if (mes == 3)
                        valor += value.mes3;
                    if (mes == 4)
                        valor += value.mes4;
                    if (mes == 5)
                        valor += value.mes5;
                    if (mes == 6)
                        valor += value.mes6;
                    if (mes == 7)
                        valor += value.mes7;
                    if (mes == 8)
                        valor += value.mes8;
                    if (mes == 9)
                        valor += value.mes9;
                    if (mes == 10)
                        valor += value.mes10;
                    if (mes == 11)
                        valor += value.mes11;
                    if (mes == 12)
                        valor += value.mes12;

                });
            }

            return valor;
        }

        $scope.GetTotalGeral = function (mes) {
            //Total Geral Mes
            var receber = $scope.GetSubTotal($scope.ObjReceber, mes);
            var pagar = $scope.GetSubTotal($scope.ObjPagar, mes);

            return receber - pagar;

        }

        $scope.filterCategoria = function (obj, categoria, subcategoria) {
            var objfilter = obj.filter(a => a.categoria == categoria && a.subcategoria == subcategoria);
            var objRet = [];


            for (var i = 1; i <= 12; i++) {

                var existeMes = objfilter.filter(a => a.Mes == i);
                if (existeMes.length > 0) {
                    objRet.push(existeMes[0]);
                }
                else
                    objRet.push({ valororiginal: 0 });
            }
            return objRet;
        }
        $scope.initialize();

    }

})();